{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Double DQN\n",
    "\n",
    "[van Hasselt et al., \"Deep Reinforcement Learning with Double Q-learning.\" arXiv preprint arXiv:1509.06461, 2015.](https://arxiv.org/pdf/1509.06461.pdf)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look at the difference between DQN and Double-DQN. The max operator in standard Q-learning and DQN uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates.\n",
    "\n",
    "$$\n",
    "\\theta_{t+1} = \\theta_t + \\alpha \\big(Y_t^Q - Q(S_t, A_t; \\theta_t)\\big) \\cdot \\nabla_{\\theta_t} Q(S_t, A_t; \\theta_t),\\\\\n",
    "\\text{where } \\alpha \\text{ is a scalar step size and the target } Y_t^Q \\text{is defined as }\\\\\n",
    "Y_t^Q = R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a; \\theta_t).\n",
    "$$\n",
    "\n",
    "In Double Q-learning ([van Hasselt 2010](https://papers.nips.cc/paper/3964-double-q-learning.pdf)), two value functions are learned by assigning experiences randomly to update one of the two value functions, resulting in two sets of weights, $\\theta$ and $\\theta'$. For each update, one set of weights is used to determine the greedy policy and the other to determine its value. For a clear comparison, we can untangle the selection and evaluation in Q-learning and rewrite DQN's target as\n",
    "\n",
    "$$\n",
    "Y_t^Q = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t).\n",
    "$$\n",
    "\n",
    "The Double Q-learning error can then be written as\n",
    "\n",
    "$$\n",
    "Y_t^{DoubleQ} = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t').\n",
    "$$\n",
    "\n",
    "The idea of Double Q-learning is to reduce overestimations by decomposing the max operation in the target into action selection and action evaluation. Although not fully decoupled, the target network in the DQN architecture provides a natural candidate for the second value function, without having to introduce additional networks. In conclusion, the weights of the second network $\\theta_t'$ are replaced with the weights of the target network for the evaluation of the current greedy policy. This makes just a small change in calculating the target value of DQN loss.\n",
    "\n",
    "##### DQN:\n",
    "\n",
    "```\n",
    "target = reward + gamma * dqn_target(next_state).max(dim=1, keepdim=True)[0]\n",
    "```\n",
    "\n",
    "##### DoubleDQN:\n",
    "\n",
    "```\n",
    "selected_action = dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "target = reward + gamma * dqn_target(next_state).gather(1, selected_action)\n",
    "```\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use `self.dqn` instead of `self.dqn_target` for action selection.\n",
    "\n",
    "```\n",
    "\n",
    "        next_q_value = self.dqn_target(next_state).gather(\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)  # Double DQN\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True) # argmax取大者的序号\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video d:\\QT\\rainbow-is-all-you-need\\videos\\double_q\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video d:\\QT\\rainbow-is-all-you-need\\videos\\double_q\\rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                               \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready d:\\QT\\rainbow-is-all-you-need\\videos\\double_q\\rl-video-episode-0.mp4\n",
      "score:  134.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/double_q\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/double_q\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "dlengine_env",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
